package com.mygameframework.core;


import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.lang.reflect.InvocationTargetException;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
    The ScreenManager class manages initializing and displaying
    full screen graphics modes.
*/
//TODO 做个Stratege开关 和 全屏/窗口 模式开关 
public class ScreenManager1 {
    private Canvas canvas;
    private JPanel panel;
    private  Frame gameWindow;
//    private GraphicsDevice graphicsDevice;
    final public static GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
    final public static GraphicsDevice graphicsDevice = environment.getDefaultScreenDevice();
    final public static GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();

    private boolean useBufferStrategy=true;
//让ScreenManager 接收一个外来的JFrame
    /**
     * 
        Creates a new ScreenManager object.
    */
    public ScreenManager1() {
//        GraphicsEnvironment environment =
//            GraphicsEnvironment.getLocalGraphicsEnvironment();
//        graphicsDevice = environment.getDefaultScreenDevice();
//        gameWindow=new JFrame();
//        ((JFrame)gameWindow).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//        gameWindow.setSize(800, 600);
    }
    public ScreenManager1(Frame f) {
        this();
        gameWindow=f;
    }

    /**
        Returns a list of compatible display modes for the
        default graphicsDevice on the system.
    */
    public DisplayMode[] getCompatibleDisplayModes() {
        return graphicsDevice.getDisplayModes();
    }

	/**
	 * 查询可用的屏幕设备
	 * 
	 * @param width
	 * @param height
	 * @return
	 */
	public final static DisplayMode searchFullScreenModeDisplay(int width,
			int height) {
		return searchFullScreenModeDisplay(graphicsDevice, width, height);
	}

	/**
	 * 查询可用的屏幕设备
	 * 
	 * @param graphicsDevice
	 * @param width
	 * @param height
	 * @return
	 */
	public final static DisplayMode searchFullScreenModeDisplay(
			GraphicsDevice device, int width, int height) {
		DisplayMode displayModes[] = device.getDisplayModes();
		int currentDisplayPoint = 0;
		DisplayMode fullScreenMode = null;
		DisplayMode normalMode = device.getDisplayMode();
		DisplayMode adisplaymode[] = displayModes;
		int i = 0, length = adisplaymode.length;
		for (int j = length; i < j; i++) {
			DisplayMode mode = adisplaymode[i];
			if (mode.getWidth() == width && mode.getHeight() == height) {
				int point = 0;
				if (normalMode.getBitDepth() == mode.getBitDepth()) {
					point += 40;
				} else {
					point += mode.getBitDepth();
				}
				if (normalMode.getRefreshRate() == mode.getRefreshRate()) {
					point += 5;
				}
				if (currentDisplayPoint < point) {
					fullScreenMode = mode;
					currentDisplayPoint = point;
				}
			}
		}
		return fullScreenMode;
	}
    /**
        Returns the first compatible mode in a list of modes.
        Returns null if no modes are compatible.
    */
    public DisplayMode findFirstCompatibleMode(
        DisplayMode modes[])
    {
        DisplayMode goodModes[] = graphicsDevice.getDisplayModes();
        for (int i = 0; i < modes.length; i++) {
            for (int j = 0; j < goodModes.length; j++) {
                if (displayModesMatch(modes[i], goodModes[j])) {
                    return modes[i];
                }
            }

        }

        return null;
    }


    /**
        Returns the current display mode.
    */
    public DisplayMode getCurrentDisplayMode() {
        return graphicsDevice.getDisplayMode();
    }


    /**
        Determines if two display modes "match". Two display
        modes match if they have the same resolution, bit depth,
        and refresh rate. The bit depth is ignored if one of the
        modes has a bit depth of DisplayMode.BIT_DEPTH_MULTI.
        Likewise, the refresh rate is ignored if one of the
        modes has a refresh rate of
        DisplayMode.REFRESH_RATE_UNKNOWN.
    */
    public boolean displayModesMatch(DisplayMode mode1,
        DisplayMode mode2)

    {
        if (mode1.getWidth() != mode2.getWidth() ||
            mode1.getHeight() != mode2.getHeight())
        {
            return false;
        }

        if (mode1.getBitDepth() != DisplayMode.BIT_DEPTH_MULTI &&
            mode2.getBitDepth() != DisplayMode.BIT_DEPTH_MULTI &&
            mode1.getBitDepth() != mode2.getBitDepth())
        {
            return false;
        }

        if (mode1.getRefreshRate() !=
            DisplayMode.REFRESH_RATE_UNKNOWN &&
            mode2.getRefreshRate() !=
            DisplayMode.REFRESH_RATE_UNKNOWN &&
            mode1.getRefreshRate() != mode2.getRefreshRate())
         {
             return false;
         }

         return true;
    }

    
    /**
        Enters full screen mode and changes the display mode.
        If the specified display mode is null or not compatible
        with this graphicsDevice, or if the display mode cannot be
        changed on this system, the current display mode is used.
        <p>
        The display uses a BufferStrategy with 2 buffers.
    */
    public void setFullScreen(DisplayMode displayMode) {
        //TODO  ScreenManager内部new JFrame不好
//        if(this.gameWindow==null){
//            this.gameWindow = new JFrame();
//            this.gameWindow.setSize(600, 400);
//        }
         final Frame frame =gameWindow;
//        if(gameWindow instanceof JFrame){
//        ((JFrame)gameWindow).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//        } else {
//            gameWindow.addWindowListener(new WindowAdapter() {
//                @Override
//                public void windowClosed(WindowEvent e) {
//                    gameWindow.dispose();
//                }
//            });
//        }
        gameWindow.setVisible(false);
        gameWindow.removeNotify();
        gameWindow.setUndecorated(true);
        gameWindow.setIgnoreRepaint(true);
        gameWindow.setResizable(false);
        
        graphicsDevice.setFullScreenWindow(frame);

        if (displayMode != null &&
            graphicsDevice.isDisplayChangeSupported())
        {
            try {
                graphicsDevice.setDisplayMode(displayMode);
            }
            catch (IllegalArgumentException ex) { }
            // fix for mac os x
            frame.setSize(displayMode.getWidth(),
                displayMode.getHeight());
        }
        gameWindow.addNotify();
        gameWindow.setVisible(true);
//        gameWindow.pack();
        gameWindow.requestFocus();
//        gameWindow.getContentPane().requestFocus();
        if (useBufferStrategy) {
            // avoid potential deadlock in 1.4.1_02
            try {
                EventQueue.invokeAndWait(new Runnable() {
                    public void run() {
                        frame.createBufferStrategy(2);
                    }
                });
            } catch (InterruptedException ex) {
                // ignore
            } catch (InvocationTargetException ex) {
                // ignore
            }//end try
        }//end if (useBufferStrategy) 

    }

//TODO 如果getGraphics()返回的是
    /**
        Gets the graphics context for the display. The
        ScreenManager uses double buffering, so applications must
        call update() to show any graphics drawn.
        <p>
        The application must dispose of the graphics object.
    */
    public synchronized Graphics2D getGraphics() {
        Window window = graphicsDevice.getFullScreenWindow();
        if (window != null) {
            BufferStrategy strategy = window.getBufferStrategy();
            if (strategy != null) {
                return (Graphics2D) strategy.getDrawGraphics();
            } else {//didnt create a bufferStrategy
                return (Graphics2D)window.getGraphics();
            }
        }//not fullscreen
        else {
//            if(!gameWindow.isVisible())gameWindow.setVisible(true);
            return (Graphics2D) gameWindow.getGraphics();
        }
    }


    /**
     * BufferStrategy 启动时才调用,用于BufferStrategy.show()
        Updates the display.
    */
    public void update() {
        Window window = graphicsDevice.getFullScreenWindow();
        if (window != null) {
            BufferStrategy strategy = window.getBufferStrategy();
            if(strategy==null) return;
            if (!strategy.contentsLost()) {
                strategy.show();
            }
        }
        // Sync the display on some systems.
        // (on Linux, this fixes event queue problems)
        Toolkit.getDefaultToolkit().sync();
    }


    /**
        Returns the window currently used in full screen mode.
        Returns null if the graphicsDevice is not in full screen mode.
    */
    public Frame getFullScreenWindow() {
        return (Frame)graphicsDevice.getFullScreenWindow();
    }


    /**
        Returns the width of the window currently used in full
        screen mode. Returns 0 if the graphicsDevice is not in full
        screen mode.
    */
    public int getWidth() {
        Window window = graphicsDevice.getFullScreenWindow();
        if (window != null) {
            return window.getWidth();
        }
        else {
            return gameWindow.getWidth();
//            return 0;
        }
    }

    public boolean isUseBufferStrategy() {
        return useBufferStrategy;
    }
    //default ture
    public void setUseBufferStrategy(boolean useBufferStrategy) {
        this.useBufferStrategy = useBufferStrategy;
    }

    /**设置游戏窗体并使其可视        f.setVisible(true);
*/
    public void setWindow(Frame f){
        this.gameWindow=f;
        
        
        if(gameWindow instanceof JFrame)
            ((JFrame)gameWindow).setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        else
            gameWindow.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent e) {
                Frame frame = (Frame) e.getSource();
                // Hide the frame by setting its visibility as false
                frame.setVisible(false);
                // Further If the frame is no longer needed, call dispose
                frame.dispose();
            }
                
            });
        
//        canvas=new Canvas();
//        gameWindow.add(canvas);
        f.setResizable(false);
        f.setVisible(true);
    }
    public Frame getGameWindow() {
        Frame f = getFullScreenWindow();
        return (f!=null)? f:gameWindow;
    }
    /**
        Returns the height of the window currently used in full
        screen mode. Returns 0 if the graphicsDevice is not in full
        screen mode.
    */
    public int getHeight() {
        Window window = graphicsDevice.getFullScreenWindow();
        if (window != null) {
            return window.getHeight();
        }
        else {
            return gameWindow.getHeight();
        }
    }
    public boolean isFullScreen(){
        return graphicsDevice.getFullScreenWindow()==null?false:true;
    }

    /**
        Restores the screen's display mode.
    */
    public synchronized  void restoreScreen() {
        Window window = graphicsDevice.getFullScreenWindow();
        if (window != null) {
            window.dispose();
        }
//        graphicsDevice.setDisplayMode(new DisplayMode(800, 600, 32, 70));
        gameWindow.setVisible(false);
        gameWindow.removeNotify();
        gameWindow.setUndecorated(false);
        graphicsDevice.setFullScreenWindow(null);
        gameWindow.addNotify();
//        windows.pack();
//        windows.setSize(width, height);
//        gameWindow.setSize(800, 600);
        gameWindow.setResizable(false);
        gameWindow.setVisible(true);
        gameWindow.requestFocus();
//        windows.getContentPane().requestFocus();
    }


    /**
        Creates an image compatible with the current display.
    */
    public BufferedImage createCompatibleImage(int w, int h,
        int transparancy)
    {
        Window window = graphicsDevice.getFullScreenWindow();
        if (window != null) {
            GraphicsConfiguration gc =
                window.getGraphicsConfiguration();
            return gc.createCompatibleImage(w, h, transparancy);
        }else{
            return graphicsDevice.getDefaultConfiguration()
                    .createCompatibleImage(w, h, transparancy);
        }
    }
}
